'''
关于集合的内置函数
1. add(): 向集合中添加元素
2. clear(): 清空集合中的所有元素
3. copy(): 返回集合的浅拷贝
4. difference(): 返回两个集合之间的差集
5. difference_update(): 移除集合中属于另一个指定集合的元素
6. discard(): 移除集合中指定的元素
7. intersection(): 返回两个集合之间的交集
8. intersection_update(): 保留集合中同时也属于另一个指定集合的元素
9. isdisjoint(): 如果两个集合没有共同的元素，返回True，否则返回False
10. issubset(): 如果一个集合是另一个集合的子集，返回True，否则返回False
11. issuperset(): 如果一个集合是另一个集合的超集，返回True，否则返回False
12. pop(): 移除集合中的一个随机元素
13. remove(): 移除集合中指定的元素，如果元素不存在则抛出KeyError错误
14. symmetric_difference(): 返回两个集合之间的对称差集
15. symmetric_difference_update(): 对集合进行就地修改，保留不属于两个指定集合之一的元素
16. union(): 返回两个集合之间的并集
17. update(): 将指定的元素添加到集合中
'''

# set.add(item) 是集合(set)对象中的一个内置函数，用于想集合中添加指定的元素，如果集合中已存在，则不会添加
# fruits = {"apple","banana","cherry"}
# fruits.add("orange")
# print(fruits)  #{'cherry', 'orange', 'banana', 'apple'}

#set.clear() 用于清空集合中所有的元素，该函数没有返回值，直接对原集合操作，
# fruits2 = {"apple", "banana", "cherry"}
# fruits2.clear()
# print(fruits2)  #set{}

#  new_set = set.copy() 返回集合的浅拷贝，即创建一个新的集合，其中包含原始集合中的所有元素，
# fruits3 = {"apple","banana","cherry"}
# new_set = fruits3.copy()
# print(new_set)  #{'apple', 'cherry', 'banana'}

# set1.difference(set2)  ，用于返回两个集合之间的差集，即返回属于第一个集合但不属于第二个集合的元素所组成的集合
# fruits1 = {"apple", "banana", "cherry"}
# fruits2 = {"banana", "orange"}
# diff_fruits = fruits1.difference(fruits2)
# print(diff_fruits)  #{'apple', 'cherry'}

# set1.difference_update(set2) 用于哦那个当前集合中删除与另一个集合的交集，它不会创建新的集合，而是修改原来的集合
#创建两个集合
# x = {1,2,3,4,5,6}
# y = {3,4,5,6,7,7,8,8,9}
# #执行差集操作
# x.difference_update(y)
# print(x)  #{1, 2}

# set.discard(element) 用于删除集合中指定的元素，它类似于remove()函数，但是如果指定的元素不存在与集合，它不会抛出异常
# my_set = {1,2,3,4,5}
# my_set.discard(2)
# print(my_set)  #{1, 3, 4, 5}

# set1.intersection(set2) 用于获取两个集合的交集，返回两个集合都有的元素组成的新集合
# set1 = {1,2,3,4,5}
# set2 = {4,5,6,7,8}
# intersection_set = set1.intersection(set2)
# print(intersection_set)  #{4, 5}

# set1.intersection_update(set2) 用于获取两个集合的交集并更新当前集合，它会直接修改当前集合，将其更新为与另一个集合的交集
# set1 = {1,2,3,4,5}
# set2 = {4,5,6,7,8}
# set1.intersection_update(set2)
# print(set1) #{4, 5}

# set1.isdisjoint(set2) 用于判断两个集合是否没有交集，如果它们没有共同集合，则返回True,
# x = {1, 2, 3, 4}
# y = {5, 6, 7, 8}
# z = {3, 4, 5, 6}
# print(x.isdisjoint(y)) # True
# print(x.isdisjoint(z))  #False

# set1.issubset(set2)  用于判断一个集合是否为另一个集合的子集，如果当前集合包含在另一个集合中，则返回True
# set1 = {1,2}
# set2 ={1,2,3,4}
# print(set1.issubset(set2)) # True

# set1.issuperset(set2)  用于判断以后个集合是否包含另一个集合，如果当前集合包含在另一个集合中，则2返回True
# set1 ={1,2,3,4}
# set2 ={1,2}
# print(set1.issuperset(set2)) # True

# set.pop() 用于删除并返回集合中的一个元素，集合是无序的，因此无法准确预测该函数返回的元素是哪个
# x = {1,2,3,4,5}
# print(x.pop())  # 1
# print(x)        # {2, 3, 4, 5}

# set.remove(item)  用于删除集合中指定的元素，如果该元素存在与集合中，则将其删除，否则抛出一个keyError异常
# x ={1,2,3,4,5}
# x.remove(3)
# print(x)  # {1, 2, 4, 5}

# set1.symmetric_difference(set2) 用于获取两个集合之间的对称差集，对称差集是指两个集合不重复的元素的集合
# set1 = {1,2,3,4}
# set2 ={3,4,5,6}
# result = set1.symmetric_difference(set2)
# print(result)  # {1, 2, 5, 6}

# set1.symmetric_difference_update(set2) 用于获取两个集合之间的对称差集，并将其更新为当前集合，对称差集是指两个集合中不重复的元素的集合
# set1 = {1,2,3,4}
# set2 = {3,4,5,6}
# set1.symmetric_difference_update(set2)
# print(set1)  # {1, 2, 5, 6}

# set1.union(set2, set3, ...) 用于获取两个或多个集合的并集，即两个或多个集合中所有元素的集合，返回的集合中不包含重复的元素
# set1 = {1, 2, 3}
# set2 = {3, 4, 5}
# result = set1.union(set2)
# print(result)  # {1, 2, 3, 4, 5}

# set1.update(set2) set1.update(iterable) 用于将另一个集合或可迭代对象中的元素添加到当前集合中
# set1 = {1,2,3}
# liset1 = [3,4,5,6]
# set1.update({6,7,8},liset1)
# print(set1)  # {1, 2, 3, 4, 5, 6, 7, 8}









